import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';
import '../models/cart_item.dart';

class CartStorage {
  static const String _cartKey = 'shopping_cart';

  // 获取购物车商品列表
  static Future<List<CartItem>> getCartItems() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final cartJson = prefs.getString(_cartKey);
      
      if (cartJson == null || cartJson.isEmpty) {
        return [];
      }

      final List<dynamic> cartList = json.decode(cartJson);
      return cartList.map((item) => CartItem.fromJson(item)).toList();
    } catch (e) {
      print('Error loading cart items: $e');
      return [];
    }
  }

  // 保存购物车商品列表
  static Future<bool> saveCartItems(List<CartItem> items) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final cartJson = json.encode(items.map((item) => item.toJson()).toList());
      return await prefs.setString(_cartKey, cartJson);
    } catch (e) {
      print('Error saving cart items: $e');
      return false;
    }
  }

  // 添加商品到购物车
  static Future<bool> addToCart(CartItem newItem) async {
    try {
      final cartItems = await getCartItems();
      
      // 检查商品是否已存在
      final existingIndex = cartItems.indexWhere((item) => item.id == newItem.id);
      
      if (existingIndex != -1) {
        // 如果商品已存在，增加数量
        cartItems[existingIndex] = cartItems[existingIndex].copyWith(
          quantity: cartItems[existingIndex].quantity + 1,
        );
      } else {
        // 如果商品不存在，添加新商品
        cartItems.add(newItem);
      }
      
      return await saveCartItems(cartItems);
    } catch (e) {
      print('Error adding to cart: $e');
      return false;
    }
  }

  // 更新商品数量
  static Future<bool> updateQuantity(int productId, int quantity) async {
    try {
      final cartItems = await getCartItems();
      final index = cartItems.indexWhere((item) => item.id == productId);
      
      if (index != -1) {
        if (quantity <= 0) {
          // 如果数量为0或负数，移除商品
          cartItems.removeAt(index);
        } else {
          // 更新数量
          cartItems[index] = cartItems[index].copyWith(quantity: quantity);
        }
        return await saveCartItems(cartItems);
      }
      return false;
    } catch (e) {
      print('Error updating quantity: $e');
      return false;
    }
  }

  // 移除商品
  static Future<bool> removeItem(int productId) async {
    try {
      final cartItems = await getCartItems();
      cartItems.removeWhere((item) => item.id == productId);
      return await saveCartItems(cartItems);
    } catch (e) {
      print('Error removing item: $e');
      return false;
    }
  }

  // 清空购物车
  static Future<bool> clearCart() async {
    try {
      final prefs = await SharedPreferences.getInstance();
      return await prefs.remove(_cartKey);
    } catch (e) {
      print('Error clearing cart: $e');
      return false;
    }
  }

  // 获取购物车商品总数
  static Future<int> getCartItemCount() async {
    try {
      final cartItems = await getCartItems();
      return cartItems.fold<int>(0, (int total, CartItem item) => total + item.quantity);
    } catch (e) {
      print('Error getting cart count: $e');
      return 0;
    }
  }

  // 获取购物车总价
  static Future<double> getCartTotal() async {
    try {
      final cartItems = await getCartItems();
      return cartItems.fold<double>(0.0, (double total, CartItem item) => total + item.totalPrice);
    } catch (e) {
      print('Error getting cart total: $e');
      return 0.0;
    }
  }
}